home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / re.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  6KB  |  227 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import sys
  5. import sre_compile
  6. import sre_parse
  7. __all__ = [
  8.     'match',
  9.     'search',
  10.     'sub',
  11.     'subn',
  12.     'split',
  13.     'findall',
  14.     'compile',
  15.     'purge',
  16.     'template',
  17.     'escape',
  18.     'I',
  19.     'L',
  20.     'M',
  21.     'S',
  22.     'X',
  23.     'U',
  24.     'IGNORECASE',
  25.     'LOCALE',
  26.     'MULTILINE',
  27.     'DOTALL',
  28.     'VERBOSE',
  29.     'UNICODE',
  30.     'error']
  31. __version__ = '2.2.1'
  32. I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE
  33. L = LOCALE = sre_compile.SRE_FLAG_LOCALE
  34. U = UNICODE = sre_compile.SRE_FLAG_UNICODE
  35. M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE
  36. S = DOTALL = sre_compile.SRE_FLAG_DOTALL
  37. X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE
  38. T = TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE
  39. DEBUG = sre_compile.SRE_FLAG_DEBUG
  40. error = sre_compile.error
  41.  
  42. def match(pattern, string, flags = 0):
  43.     return _compile(pattern, flags).match(string)
  44.  
  45.  
  46. def search(pattern, string, flags = 0):
  47.     return _compile(pattern, flags).search(string)
  48.  
  49.  
  50. def sub(pattern, repl, string, count = 0):
  51.     return _compile(pattern, 0).sub(repl, string, count)
  52.  
  53.  
  54. def subn(pattern, repl, string, count = 0):
  55.     return _compile(pattern, 0).subn(repl, string, count)
  56.  
  57.  
  58. def split(pattern, string, maxsplit = 0):
  59.     return _compile(pattern, 0).split(string, maxsplit)
  60.  
  61.  
  62. def findall(pattern, string, flags = 0):
  63.     return _compile(pattern, flags).findall(string)
  64.  
  65. if sys.hexversion >= 33685504:
  66.     __all__.append('finditer')
  67.     
  68.     def finditer(pattern, string, flags = 0):
  69.         return _compile(pattern, flags).finditer(string)
  70.  
  71.  
  72.  
  73. def compile(pattern, flags = 0):
  74.     return _compile(pattern, flags)
  75.  
  76.  
  77. def purge():
  78.     _cache.clear()
  79.     _cache_repl.clear()
  80.  
  81.  
  82. def template(pattern, flags = 0):
  83.     return _compile(pattern, flags | T)
  84.  
  85. _alphanum = { }
  86. for c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890':
  87.     _alphanum[c] = 1
  88.  
  89. del c
  90.  
  91. def escape(pattern):
  92.     s = list(pattern)
  93.     alphanum = _alphanum
  94.     for i in range(len(pattern)):
  95.         c = pattern[i]
  96.         if c not in alphanum:
  97.             if c == '\x00':
  98.                 s[i] = '\\000'
  99.             else:
  100.                 s[i] = '\\' + c
  101.         c == '\x00'
  102.     
  103.     return pattern[:0].join(s)
  104.  
  105. _cache = { }
  106. _cache_repl = { }
  107. _pattern_type = type(sre_compile.compile('', 0))
  108. _MAXCACHE = 100
  109.  
  110. def _compile(*key):
  111.     cachekey = (type(key[0]),) + key
  112.     p = _cache.get(cachekey)
  113.     if p is not None:
  114.         return p
  115.     
  116.     (pattern, flags) = key
  117.     if isinstance(pattern, _pattern_type):
  118.         return pattern
  119.     
  120.     if not sre_compile.isstring(pattern):
  121.         raise TypeError, 'first argument must be string or compiled pattern'
  122.     
  123.     
  124.     try:
  125.         p = sre_compile.compile(pattern, flags)
  126.     except error:
  127.         v = None
  128.         raise error, v
  129.  
  130.     if len(_cache) >= _MAXCACHE:
  131.         _cache.clear()
  132.     
  133.     _cache[cachekey] = p
  134.     return p
  135.  
  136.  
  137. def _compile_repl(*key):
  138.     p = _cache_repl.get(key)
  139.     if p is not None:
  140.         return p
  141.     
  142.     (repl, pattern) = key
  143.     
  144.     try:
  145.         p = sre_parse.parse_template(repl, pattern)
  146.     except error:
  147.         v = None
  148.         raise error, v
  149.  
  150.     if len(_cache_repl) >= _MAXCACHE:
  151.         _cache_repl.clear()
  152.     
  153.     _cache_repl[key] = p
  154.     return p
  155.  
  156.  
  157. def _expand(pattern, match, template):
  158.     template = sre_parse.parse_template(template, pattern)
  159.     return sre_parse.expand_template(template, match)
  160.  
  161.  
  162. def _subx(pattern, template):
  163.     template = _compile_repl(template, pattern)
  164.     if not template[0] and len(template[1]) == 1:
  165.         return template[1][0]
  166.     
  167.     
  168.     def filter(match, template = template):
  169.         return sre_parse.expand_template(template, match)
  170.  
  171.     return filter
  172.  
  173. import copy_reg
  174.  
  175. def _pickle(p):
  176.     return (_compile, (p.pattern, p.flags))
  177.  
  178. copy_reg.pickle(_pattern_type, _pickle, _compile)
  179.  
  180. class Scanner:
  181.     
  182.     def __init__(self, lexicon, flags = 0):
  183.         BRANCH = BRANCH
  184.         SUBPATTERN = SUBPATTERN
  185.         import sre_constants
  186.         self.lexicon = lexicon
  187.         p = []
  188.         s = sre_parse.Pattern()
  189.         s.flags = flags
  190.         for phrase, action in lexicon:
  191.             p.append(sre_parse.SubPattern(s, [
  192.                 (SUBPATTERN, (len(p) + 1, sre_parse.parse(phrase, flags)))]))
  193.         
  194.         s.groups = len(p) + 1
  195.         p = sre_parse.SubPattern(s, [
  196.             (BRANCH, (None, p))])
  197.         self.scanner = sre_compile.compile(p)
  198.  
  199.     
  200.     def scan(self, string):
  201.         result = []
  202.         append = result.append
  203.         match = self.scanner.scanner(string).match
  204.         i = 0
  205.         while None:
  206.             m = match()
  207.             if not m:
  208.                 break
  209.             
  210.             j = m.end()
  211.             if i == j:
  212.                 break
  213.             
  214.             action = self.lexicon[m.lastindex - 1][1]
  215.             if callable(action):
  216.                 self.match = m
  217.                 action = action(self, m.group())
  218.             
  219.             if action is not None:
  220.                 append(action)
  221.             
  222.             i = j
  223.             continue
  224.             return (result, string[i:])
  225.  
  226.  
  227.